Linearizability Is Not Always a Safety Property
نویسندگان
چکیده
We show that, in contrast to the general belief in the distributed computing community, linearizability, the celebrated consistency property, is not always a safety property. More specifically, we give an object for which it is possible to have an infinite history that is not linearizable, even though every finite prefix of the history is linearizable. The object we consider as a counterexample has infinite nondeterminism. We show, however, that if we restrict attention to objects with finite nondeterminism, we can use König’s lemma to prove that linearizability is indeed a safety property. In the same vein, we show that the backward simulation technique, which is a classical technique to prove linearizability, is not sound for arbitrary types, but is sound for types with finite nondeterminism.
منابع مشابه
Characterizing Progress Properties of Concurrent Objects via Contextual Refinements
Implementations of concurrent objects should guarantee linearizability and a progress property such as wait-freedom, lock-freedom, obstruction-freedom, starvation-freedom, or deadlock-freedom. Conventional informal or semi-formal definitions of these progress properties describe conditions under which a method call is guaranteed to complete, but it is unclear how these definitions can be utiliz...
متن کاملDraft – April 16 , 2013 Observing Progress Properties via Contextual Refinements ( Extended Version )
Implementations of concurrent objects should guarantee linearizability and a progress property such as wait-freedom, lock-freedom, obstruction-freedom, starvation-freedom, or deadlock-freedom. Conventional informal or semi-formal definitions of these progress properties describe conditions under which a method call is guaranteed to complete, but it is unclear how these definitions can be utiliz...
متن کاملChecking Correctness of Concurrent Objects: Tractable Reductions to Reachability (Invited Talk)
Efficient implementations of concurrent objects such as semaphores, locks, and atomic collections including stacks and queues are vital to modern computer systems. Programming them is however error prone. To minimize synchronization overhead between concurrent object-method invocations, implementors avoid blocking operations like lock acquisition, allowing methods to execute concurrently. Howev...
متن کاملNormality: A Consistency Condition for Concurrent Objects
Linearizability is a consistency condition for concurrent objects (objects shared by concurrent processes) that exploits the semantics of abstract data types. It provides the illusion that each operation applied by concurrent processes takes eeect instantaneously at some point between the beginning and the end of its execution. When compared with other consistency conditions (such as sequential...
متن کاملA Constructive Proof On the Compositionality of Linearizability
Linearizability is the strongest correctness property for both shared memory and message passing concurrent systems. One promising nature of linearizability is the compositionality: a history(execution) is linearizable if and only if each object subhistory is linearizable, which is instructive in that we are able to design, implement and test a whole system from the bottom up. In this paper, we...
متن کامل